AVERTISSEMENT

Le présent manuel a pour seul objectif de guider les étudiants dans leur initiation au logiciel R. Ce dernier demeure un outil vaste et complexe, dont l’apprentissage est un processus continu en raison des mises à jour fréquentes et du développement constant de nouveaux packages. Ce document ne prétend nullement se substituer aux ouvrages spécialisés qui explorent le sujet de manière exhaustive et que nous recommandons vivement pour un apprentissage approfondi. Néanmoins, nous espérons que le résumé présenté ci-dessous offrira aux novices une introduction aux fonctions élémentaires de R et facilitera leur prise en main du logiciel.

INTRODUCTION

R: un aperçu

R est un langage de programmation et un environnement informatique spécialisé dans le calcul statistique, l’analyse de données et leur visualisation. Initialement développé au milieu des années 1990 par Ross Ihaka et Robert Gentleman aux Laboratoires Bell, R est, depuis 1997, maintenu et organisé par la R Development Core Team. Ce logiciel, distribué sous licence Open Source, fait partie du projet GNU et est compatible avec les systèmes d’exploitation Unix, Macintosh et Windows.

R se distingue comme un outil d’apprentissage et d’application des statistiques, offrant un cadre cohérent et extensible pour l’analyse des données. Sa nature Open Source garantit une accessibilité universelle, le rendant adapté aussi bien aux étudiants qu’aux chercheurs, analystes et data scientists. Grâce à sa flexibilité et à ses nombreuses bibliothèques (ou packages), R est particulièrement prisé pour des domaines tels que les statistiques avancées et le machine learning. Il permet la création de visualisations sophistiquées, ce qui renforce son utilité dans divers contextes. Enfin, R bénéficie d’une vaste communauté d’utilisateurs et de milliers de packages disponibles via le CRAN (Comprehensive R Archive Network), ce qui en fait un outil puissant, gratuit et en constante évolution.

RStudio : un environnement intégré pour R

RStudio est un environnement de développement intégré (IDE=integrated development environment) conçu spécifiquement pour faciliter la programmation en R. Il propose une interface conviviale et intuitive qui simplifie l’utilisation de R en organisant efficacement les différents aspects du travail, comme l’écriture de code, l’exécution des scripts, l’analyse des données et la visualisation.

RStudio est régulièrement mis à jour, et lorsque votre ordinateur est connecté à Internet, l’IDE signale la disponibilité d’une nouvelle version. Il est vivement recommandé de maintenir RStudio à jour afin de bénéficier des dernières fonctionnalités et améliorations. Grâce à cette interface optimisée, RStudio améliore considérablement l’expérience utilisateur et permet aux programmeurs de travailler de manière plus productive et structurée.

PAR OÙ COMMENCER: commencez par l’installation des logiciels

L’utilisation de R et RStudio commence par l’installation de ces logiciels sur votre ordinateur. Il est essentiel de télécharger et d’installer les versions compatibles avec votre système d’exploitation (Windows, macOS ou Linux). Voici les étapes à suivre : 1. Téléchargement de R et RStudio Rendez-vous sur le site officiel à l’adresse suivante :https://posit.co/download/rstudio-desktop/. Téléchargez les fichiers d’installation de R et de RStudio, puis procédez à leur installation en suivant les instructions fournies à l’écran. Il est recommandé d’accepter les paramètres par défaut pour une installation standard et optimisée. 2. Installation de RTools (uniquement pour Windows) Si vous utilisez Windows, il est également nécessaire d’installer le logiciel RTools, disponible sur le site suivant :https://cran.r-project.org/bin/windows/Rtools/ RTools est indispensable pour installer et compiler certains packages R directement à partir de leur code source.

En suivant ces étapes, vous serez prêt à utiliser R et RStudio pour vos analyses de données et vos travaux en programmation statistique.

IMPORTANT À NOTER: Lors de l’utilisation de ces outils, seul RStudio sera lancé directement sur votre ordinateur. En revanche, R et RTools s’exécutent en arrière-plan et n’ont pas besoin d’être ouverts manuellement. RStudio agit comme une interface centrale qui facilite l’interaction avec R, tandis que RTools (sur Windows) est utilisé automatiquement lorsque nécessaire, notamment pour l’installation et la compilation de certains packages comme nous l’avons dit ci-haut.

PRESENTATION DE L’INTERFACE RSTUDIO

Lorsque vous ouvrez RStudio, l’interface est divisée en quatre volets principaux :

  1. Volet Source (en haut à gauche)

C’est ici que vous écrivez, modifiez et sauvegardez vos scripts ou documents R Markdown. Utilisation : * Écrire et sauvegarder des scripts R (.R) ou des documents R Markdown (.Rmd). * Exécuter une ligne ou un bloc de code en utilisant Ctrl + Enter (Windows/Linux) ou Cmd + Enter (Mac). Fonctions principales : * Numéros de lignes pour une meilleure navigation. * Coloration syntaxique pour identifier les commandes, commentaires, etc. * Onglets multiples pour travailler sur plusieurs fichiers.

  1. Volet Console (en bas à gauche)

La console est la zone où les commandes sont exécutées directement. Elle permet une interaction immédiate avec R. Utilisation : * Saisir des commandes R directement et voir leurs résultats instantanément. * Afficher des messages d’erreur ou des avertissements. * Exemple :

print(“Est-ce tout le monde va bien?”)

  1. Volet Environment/History (en haut à droite)

Ce volet est dédié à la gestion des objets (données, variables, fonctions) créés pendant la session. * Environment : ** Affiche tous les objets disponibles (comme les variables, tableaux ou fonctions). ** Possibilité de les supprimer ou de les visualiser (par exemple, afficher une table de données dans une vue en tableau). * History : ** Liste des commandes exécutées. ** Permet de rejouer ou copier des commandes passées.

  1. Volet Plots/Files/Packages/Help/Viewer (en bas à droite)

Ce volet regroupe plusieurs fonctionnalités: * Plots : ** Affiche les graphiques générés par vos commandes. ** Options pour sauvegarder, redimensionner ou copier vos graphiques. * Files : ** Explore les fichiers du répertoire de travail. ** Permet de naviguer et de gérer vos fichiers. * Packages : ** Affiche les packages R installés. ** Permet d’installer, charger ou mettre à jour des packages. * Help : ** Fournit une aide détaillée sur les fonctions ou packages (tapez ?fonction pour accéder à la documentation). * Viewer : ** Affiche du contenu HTML (par exemple, les rapports générés avec R Markdown).

Fonctions supplémentaires utiles * Barre de menu (en haut) : Accès rapide aux fonctionnalités comme créer un nouveau fichier, ouvrir un projet ou personnaliser vos paramètres. * Console de débogage (lorsqu’un programme est en cours d’exécution) : Permet de diagnostiquer et de corriger des erreurs dans votre code.

Cette image décrit les principaux volets (fenêtres) de l’interface R studio

Cette image décrit quelques options de la barre de menu

Exemple

Dans le volet Source, taper les commandes suivantes et remarquez ce qui s’affiche dans les autres volets:

?mean()
??ggplot()
v1 = 45 # Le symbole <- est egalement utilisé pour exprimer l'égalité (dans le cadre d'assignation d'une valeur à un objet R).  
v2 = 15 # Le symbole <- est obtenu par le racourci clavier Optio + - sur Mac ou ALT + = sur Windows
v3 = 3 # Pour valider une commande R, la sélectionner puis taper CTRL/CMD + ENTER ou cliquer sur RUN dans le voler Source (coin supérieur gauche)
v4 = (v1*v3)/v2
print(v4)
## [1] 9

NOTIONS DE PACKAGE (library ou bibliothèque)

Un package en R est un ensemble de fonctions, de données et de documentation organisés de manière cohérente pour accomplir des tâches spécifiques et coompler les fonctions de base de R.

Les packages permettent d’étendre les fonctionnalités de base du langage R et d’ajouter des outils supplémentaires pour des domaines spécifiques comme la statistique, la visualisation de données, le machine learning, etc.

Par exemple, le package ggplot2 fournit des fonctions pour créer des graphiques complexes, et le package dplyr offre des outils pour la manipulation de données.

Les principaux composants d’un package incluent :

  1. Fonctions : Des scripts pré-écrits qui effectuent des tâches spécifiques. Exemple:
  1. Données : Certains packages incluent des jeux de données prédéfinis pour des analyses ou des démonstrations. Exemple:
  1. Documentation : Des guides et descriptions expliquant comment utiliser les fonctions et les données incluses dans le package.

R dispose d’une grande bibliothèque de packages que vous pouvez installer à partir du CRAN (Comprehensive R Archive Network) ou de sources comme GitHub.

Il existe deux manières d’installer un package: 1. En tapant un script dans le volet Source:

install.packages(“nom_du_package”)

Exemple:

install.packages(“readxl”) Incluant les «dependencies» : install.packages(“nom_du_package”, dependencies = TRUE)

Exemple: install.packages(“showtext”, dependencies = TRUE)

  1. En suivant cliquant Tools > Install packages > choisir Install from CRAN > Taper le nom du package ou le rechercher dans le menu Packages > Cocher Install dependencies puis cliquer sur Installer.

Cette image montre l’installation d’un package à l’aide du menu Tools

Exemple des packages dans R

Un package R n’a besoin d’être installé qu’une seule fois sur votre système, sauf si vous souhaitez le mettre à jour. Cependant, pour l’utiliser dans une session R donnée, il doit être activé/chargé à l’aide de la commande suivante :

library(nom_du_package)

ou équivalent :

library(“nom_du_package”)

Par exemple :

Activation du package ggplot2

library(ggplot2)

Cela permet de charger les fonctionnalités du package dans la session en cours, ce qui le rend immédiatement utilisable. Si vous fermez et rouvrez une session R, vous devrez réactiver les packages nécessaires.

Description du package tidyverse

Le tidyverse est une collection de packages R conçus pour simplifier et normaliser l’analyse des données. Il repose sur une philosophie commune et une syntaxe cohérente pour >manipuler, transformer et visualiser les données de manière intuitive.

Objectifs principaux du tidyverse :

  • Simplifier l’analyse des données grâce à une syntaxe intuitive et facile à lire.
  • Promouvoir les bonnes pratiques en structurant les données dans un format dit “tidy” : chaque ligne représente une observation, chaque colonne une variable.
  • Créer des pipelines efficaces grâce à l’opérateur pipe (%>%), permettant de chaîner plusieurs étapes de transformation sans devoir stocker des variables intermédiaires.

Principaux packages du tidyverse

Le tidyverse comprend plusieurs packages essentiels pour travailler avec des données.

  1. ggplot2 : Visualisation des données

Permet de créer des graphiques élégants et personnalisables à partir de la grammaire graphique.

library(ggplot2)
data(mtcars)  # Charge le dataset intégré
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point() +
  labs(title = "Consommation d'essence par poids",
       x = "Poids (en tonnes)",
       y = "Consommation (miles par gallon)")

  1. dplyr : Manipulation des données
  • Fournit des fonctions intuitives pour filtrer, trier, résumer et manipuler des données tabulaires.
library(dplyr)
## 
## Attaching package: 'dplyr'
## The following objects are masked from 'package:stats':
## 
##     filter, lag
## The following objects are masked from 'package:base':
## 
##     intersect, setdiff, setequal, union
data(mtcars)  # Charge le dataset intégré
mtcars %>%
  filter(mpg > 20) %>%
  summarise(mean_weight = mean(wt))
##   mean_weight
## 1    2.418071
  1. tidyr : Restructuration des données
  • Aide à organiser et réorganiser les données pour les rendre exploitables.
library(tidyr)
data <- tibble(
  nom = c("A", "B"),
  math = c(80, 90),
  science = c(85, 95)
)

data_long <- data %>%
  pivot_longer(cols = c(math, science), 
               names_to = "matière", 
               values_to = "score")
print(data_long)
## # A tibble: 4 × 3
##   nom   matière score
##   <chr> <chr>   <dbl>
## 1 A     math       80
## 2 A     science    85
## 3 B     math       90
## 4 B     science    95
  1. readr : Importation des données
  • Permet de lire rapidement des fichiers CSV, TSV ou autres fichiers texte.

library(readr) data <- read_csv(“data.csv”)

  1. tibble : Amélioration des data frames
  • Introduit une version moderne et plus lisible des cadres de données traditionnels.
library(tibble)
tibble(
  x = 1:5,
  y = x^2
)
## # A tibble: 5 × 2
##       x     y
##   <int> <dbl>
## 1     1     1
## 2     2     4
## 3     3     9
## 4     4    16
## 5     5    25
  1. stringr : Manipulation des chaînes de caractères
  • Simplifie les opérations comme la recherche, la transformation ou la manipulation de textes.
library(stringr)
str_detect(c("cat", "dog"), "ch")  # Vérifie si "ch" est présent dans les chaînes
## [1] FALSE FALSE
  1. forcats : Gestion des facteurs
  • Facilite le travail avec des variables catégorielles.
library(forcats)
fct_relevel(factor(c("B", "A", "C")), "A")
## [1] B A C
## Levels: A B C

Installation du tidyverse L’ensemble des packages du tidyverse peut être installé avec une seule commande : install.packages(“tidyverse”) Pour les charger ensuite : library(tidyverse)

Exemple complet avec le tidyverse

Voici un exemple combinant plusieurs packages pour manipuler et visualiser des données :

library(tidyverse) # Chargement des données
## ── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
## ✔ lubridate 1.9.3     ✔ readr     2.1.5
## ✔ purrr     1.0.2     
## ── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
## ✖ dplyr::filter() masks stats::filter()
## ✖ dplyr::lag()    masks stats::lag()
## ℹ Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors
data <- mtcars # Manipuler et visualiser les données
data %>%
  filter(mpg > 20) %>%                  # Filtrer les voitures avec plus de 20 mpg
  mutate(kpl = mpg * 0.425144) %>%      # Ajouter une colonne avec la consommation en km/L
  group_by(cyl) %>%                     # Regrouper par nombre de cylindres
  summarise(avg_kpl = mean(kpl)) %>%    # Calculer la consommation moyenne par groupe
  ggplot(aes(x = factor(cyl), y = avg_kpl, fill = factor(cyl))) +
  geom_col() +
  labs(title = "Consommation moyenne par cylindre",
       x = "Nombre de cylindres",
       y = "Consommation moyenne (km/L)")

TROUVER DE L’AIDE

help.start(): affiche des liens vers plusieurs ressources d’information et de formation (packages, introduction à R, etc.) Menu Tools > Keyboards Shortcuts Help: pour afficher les raccourcis clavier. ?fonction: pour afficher de l’aide sur une fonction: * Exemple: ?mean ??fonction: pour afficher le package auquel appartient une fonction. * Exemple ??mean help(package=«package_name»): obtenir de l’aide sur un package * Exemple: help(package=«ggplot2»)

AUTRES FONCTIONS

setwd(«/chemin/d’accès/au/dossier/de/travail/»): pour indiquer le dossier de travail, où se trouve la base des données et où les résultats (graphiques) seront sauvegardés) getwd(): afficher le chemin d’accès vers le dossier de travail

EXEMPLES DE CODES OU SCRIPTS

Manipulations sur une variable quantitaive

#obtenir un résumé avec le package DescTools 
install.packages("DescTools", repos="http://cran.rstudio.com/", dependencies=TRUE) # pour installer le package 
## Warning: unable to access index for repository http://cran.rstudio.com/src/contrib:
##   cannot open URL 'http://cran.rstudio.com/src/contrib/PACKAGES'
## Warning: package 'DescTools' is not available for this version of R
## 
## A version of this package for your version of R might be available elsewhere,
## see the ideas at
## https://cran.r-project.org/doc/manuals/r-patched/R-admin.html#Installing-packages
## Warning: unable to access index for repository http://cran.rstudio.com/bin/macosx/big-sur-arm64/contrib/4.4:
##   cannot open URL 'http://cran.rstudio.com/bin/macosx/big-sur-arm64/contrib/4.4/PACKAGES'
library(DescTools) # charger le package DescTools
library(tidyverse) # charger le package tidyverse

# créons des fausses donnêes pour la pratique. Les mêmes fonctions peuvent être appliquêes aux vraies données
Input =("v0 v1 v2   v3 
12.4    45.15   1.25    1115.2
13.5    26.15   0.99    1216.4
16.3    78.14   1.63    1426.1
14.9    56.35   1.34    1635.2
14.5    65.21   0.96    1345.6
13.9    63.15   1.26    1248.3
18.2    46.15   0.64    1632.5
16.7    48.23   1.54    1458.6
23.2    86.35   1.48    1752.6
10.9    46.15   1.78    1496.8
23.9    31.25   0.69    1835.6
24.8    48.26   1.16    1934.6
26.1    46.23   1.49    1536.4
24.7    32.56   1.25    1269.7")

data = as.data.frame(read.table(textConnection(Input), header=TRUE)) # génère un tableau ou une base de données (=dataframe)
data #visualiser le tableau
##      v0    v1   v2     v3
## 1  12.4 45.15 1.25 1115.2
## 2  13.5 26.15 0.99 1216.4
## 3  16.3 78.14 1.63 1426.1
## 4  14.9 56.35 1.34 1635.2
## 5  14.5 65.21 0.96 1345.6
## 6  13.9 63.15 1.26 1248.3
## 7  18.2 46.15 0.64 1632.5
## 8  16.7 48.23 1.54 1458.6
## 9  23.2 86.35 1.48 1752.6
## 10 10.9 46.15 1.78 1496.8
## 11 23.9 31.25 0.69 1835.6
## 12 24.8 48.26 1.16 1934.6
## 13 26.1 46.23 1.49 1536.4
## 14 24.7 32.56 1.25 1269.7
#   Fonctions statistiques pour une variable quantitaive x

x = data$v0 # x=data$v0 veut dire que nous assignons à l'objet x les valeurs de la variable vO appartenant au dataframe nommé data
    
sum(x) # Calcule la somme des valeurs de x
## [1] 254
mean(x) # Calcule la moyenne des valeurs de x   
## [1] 18.14286
median(x) # Calcule la médiane des valeurs de x 
## [1] 16.5
Mode(x) # Calcule le mode des valeurs de x  à partir de Desctool
## [1] NA
## attr(,"freq")
## [1] NA
max(x) # Affiche le maximum des valeurs de x    
## [1] 26.1
min(x) # Affiche le minimum des valeurs de x    
## [1] 10.9
sd(x) # Calcule l'écart-type des valeurs de x   
## [1] 5.288698
var(x) # Calcule la variance des valeurs de x   
## [1] 27.97033
quantile(x) # Calcule les qunatiles des valeurs de x    
##     0%    25%    50%    75%   100% 
## 10.900 14.050 16.500 23.725 26.100
length(x) # Calcule la taille de la variable x  
## [1] 14
#t.test(x, y, alternative, mu, paired, var.equal, .)
t.test(x, mu = 5) # comparaison moyenne observée vs moyenne théorique
## 
##  One Sample t-test
## 
## data:  x
## t = 9.2983, df = 13, p-value = 4.156e-07
## alternative hypothesis: true mean is not equal to 5
## 95 percent confidence interval:
##  15.08925 21.19646
## sample estimates:
## mean of x 
##  18.14286
t.test(data$v0, data$v1) # comparaison deux moyennes observées
## 
##  Welch Two Sample t-test
## 
## data:  data$v0 and data$v1
## t = -6.925, df = 15.447, p-value = 4.139e-06
## alternative hypothesis: true difference in means is not equal to 0
## 95 percent confidence interval:
##  -43.44248 -23.03323
## sample estimates:
## mean of x mean of y 
##  18.14286  51.38071
t.test(data$v0, data$v1, paired = TRUE, var.equal = TRUE) # paired t-test:cannot compute exact p-value with ties
## 
##  Paired t-test
## 
## data:  data$v0 and data$v1
## t = -6.7733, df = 13, p-value = 1.315e-05
## alternative hypothesis: true mean difference is not equal to 0
## 95 percent confidence interval:
##  -43.83912 -22.63660
## sample estimates:
## mean difference 
##       -33.23786
#U-test wilcox.test(x, y, alternative, mu, paired, .)
wilcox.test(data$v0, data$v1) #Warning message:In wilcox.test.default(data$v0, data$v1) :
## Warning in wilcox.test.default(data$v0, data$v1): cannot compute exact p-value
## with ties
## 
##  Wilcoxon rank sum test with continuity correction
## 
## data:  data$v0 and data$v1
## W = 0, p-value = 7.446e-06
## alternative hypothesis: true location shift is not equal to 0
wilcox.test(data$v0, data$v1, exact = FALSE)
## 
##  Wilcoxon rank sum test with continuity correction
## 
## data:  data$v0 and data$v1
## W = 0, p-value = 7.446e-06
## alternative hypothesis: true location shift is not equal to 0
# Test de l'homogénéité des variances et de la noramalité
#Regarder à la distribution grâce à un graphique
library("ggpubr")
ggdensity(data$v0, 
          main = "Density plot of v0",
          xlab = "v0") # trace un graphique de la variable

ggqqplot(data$v0) #

# Shapiro-Wilk test pour une distribution individuelle
shapiro.test(data$v0)
## 
##  Shapiro-Wilk normality test
## 
## data:  data$v0
## W = 0.8892, p-value = 0.07871
shapiro.test(data$v1)
## 
##  Shapiro-Wilk normality test
## 
## data:  data$v1
## W = 0.9372, p-value = 0.3837
### La distribution suit la loi normale lorsque la valeur de p est >0,05

######################”

Test de Chi-carré

Input2 =("
Patient Pf  Pm  Pv Po Pk Gender Education
SLV1     47  10  40 2  2 M Yes
SLV2   19  3   5  0  2 M No
SLV3   50  0   10 7  0 F Yes
SLV4    46  16  8  4  0 F No")
data2 = as.data.frame(read.table(textConnection(Input2), header=TRUE))
data2
##   Patient Pf Pm Pv Po Pk Gender Education
## 1    SLV1 47 10 40  2  2      M       Yes
## 2    SLV2 19  3  5  0  2      M        No
## 3    SLV3 50  0 10  7  0      F       Yes
## 4    SLV4 46 16  8  4  0      F        No
#créer une nouvelle variable
data2 = data2 %>% mutate(Pm01=case_when(Pm==0 ~ "Negative",
                        Pm>0 ~ "Positive"))

table(data2$Pm01,data2$Gender)
##           
##            F M
##   Negative 1 0
##   Positive 1 2
#make a 2x2 table
cs = chisq.test(table(data2$Pm01,data2$Gender))
## Warning in chisq.test(table(data2$Pm01, data2$Gender)): Chi-squared
## approximation may be incorrect
cs
## 
##  Pearson's Chi-squared test with Yates' continuity correction
## 
## data:  table(data2$Pm01, data2$Gender)
## X-squared = 0, df = 1, p-value = 1

Créer des graphiques de qualité avec R

Aperçu sur la création des graphiques dans R

Règles * Nombre de variables à tracer ; => type de variable : catégorielle, continue, temporelle, etc. ** 1 variable: *** Si variable catégorielle : on peut tracer histogrammes, diagrammes à secteurs *** Si variable continue : tracés d’index, tracés de séries temporelles, ** 2 variables: *** Si variables catégorielles : histogrammes *** Si 1 catégorielle, 1 continue : boxplot ou barplot *** Si 2 continues : nuages de points

Outils

Graphiques de base R: graphiques basiques pas très grande qualité. Packages de traçage de graphiques dans R (par exemple ggplot2): génère des graphiques de grande qualité et hautement personnalisable.

Types de tracés

Importation des donées

library(readxl) # package qui permet d'important une base des données Excel ou csv. Si le package n'est pas installé, l'installer.
setwd("/Volumes/MySD24933/Administration/UM") # spécifie le répertoire ou dossierde travail et oú se trouve la base des données. À spécifier en fonction de sa machine
getwd() # affiche le répertoire de travail
## [1] "/Volumes/MySD24933/Administration/UM"
df <- read_excel("base_exercicesurR.xlsx", sheet = "base_exercicesurR", na = "") # commande intégrée à readxl permettant l'importation des données excel.
#View(df) # affiche la base des données
tail(df) # affiche les 6 derniéres données de la base des données
## # A tibble: 6 × 8
##     Hp1  Res1   Hp2  Res2 Sexe       Age Statut_marital disease
##   <dbl> <dbl> <dbl> <dbl> <chr>    <dbl> <chr>            <dbl>
## 1  97.6     1  86.8     1 Masculin    29 Marie                1
## 2  99.1     1  88.4     1 Masculin    27 Marie                1
## 3  81.7     1  89.6     1 Masculin    41 Marie                1
## 4  86.7     1  91.9     1 Féminin     29 Célibataire          1
## 5  51.7     1  92.9     1 Féminin     69 Veuf                 1
## 6  86.2     1  97.4     1 Masculin    55 Veuf                 1
head(df) # affiche les 6 premières données de la base des données
## # A tibble: 6 × 8
##     Hp1  Res1   Hp2  Res2 Sexe       Age Statut_marital disease
##   <dbl> <dbl> <dbl> <dbl> <chr>    <dbl> <chr>            <dbl>
## 1  10.8     0  10       0 Féminin     27 Marie                0
## 2   8.6     0  10       0 Masculin    34 Marie                0
## 3  13.1     0  10.1     0 Féminin     49 Marie                0
## 4  13.7     0  10.2     0 Masculin    67 Marie                0
## 5   8.2     0  10.2     0 Féminin     48 Marie                0
## 6  11.5     0  10.3     0 Féminin     43 Marie                0
str(df) # affiche la structure des données de la base des données
## tibble [425 × 8] (S3: tbl_df/tbl/data.frame)
##  $ Hp1           : num [1:425] 10.8 8.6 13.1 13.7 8.2 11.5 14.2 7 11.8 15.1 ...
##  $ Res1          : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
##  $ Hp2           : num [1:425] 10 10 10.1 10.2 10.2 10.3 10.4 10.5 10.6 10.7 ...
##  $ Res2          : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
##  $ Sexe          : chr [1:425] "Féminin" "Masculin" "Féminin" "Masculin" ...
##  $ Age           : num [1:425] 27 34 49 67 48 43 30 22 25 70 ...
##  $ Statut_marital: chr [1:425] "Marie" "Marie" "Marie" "Marie" ...
##  $ disease       : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...

Fonctions pour tracer les graphqies

Créer un Scatter Plot

Avec les fonctions basiques de R: synthaxe: plot(y~x) ou plot(y,x)

Exemple:

plot(df$Hp1, df$Hp2)

Avec ggplot : synthaxe: qplot(x, y) ou ggplot() + geom_point()

Exeemple:

qplot(df$Hp1, df$Hp2)
## Warning: `qplot()` was deprecated in ggplot2 3.4.0.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.

qplot(Hp1, Hp2, data=df)

ggplot(df, aes(x=Hp1, y=Hp2)) + geom_point()

Créer un Line Graph

Avec les fonctions basiques de R: synthaxe : plot(y,x, type=“l”)

Exemple:

plot(df$Hp1, df$Hp2, type="p")

plot(df$Hp1, df$Hp2, type="l") 

plot(df$Hp1, df$Hp2, type="b")

plot(df$Hp1, df$Hp2, type="l")
points(df$Hp1, df$Hp2)
lines(df$Hp1, df$Hp2/2, col="red")
points(df$Hp1, df$Hp2/2, col="red")

Avce ggplot: syntaxes: qplot(x, y, geom=“line”) ou ggplot() + geom_line() qplot(df\(Hp1, df\)Hp2, geom=“line”)

ggplot(df, aes(x=Hp1, y=Hp2)) + geom_line()

ggplot(df, aes(x=Hp1, y=Hp2)) + geom_point()

ggplot(df, aes(x=Hp1, y=Hp2)) + geom_line() + geom_point()

qplot(Hp1, Hp2, data=df, geom=c("line", "point"))

Créer un graphique à barres

Avec les fonctions basiques de R:

Exemple:

#par(mfrow=c(1,2))
barplot(table(df$Statut_marital))

#par(mfrow=c(1,1))

Avec ggplot

Exemple:

qplot(df$Hp1)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

qplot(df$Sexe)

qplot(factor(df$Statut_marital))

qplot(factor(Statut_marital), data=df)# Bar graph des comptes

ggplot(df, aes(x=factor(Statut_marital))) + geom_bar() # son équivalent

Créer un histogramme

Avec les fonctions basiques de R:

Exemple:

par(mfrow=c(2,2))
hist(df$Hp1)
hist(df$Hp1, breaks=5)# Specify approximate number of bins with breaks
par(mfrow=c(1,1))

Avec ggplot:

Exemple:

qplot(df$Hp2)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

qplot(Hp2, data=df, binwidth=4) #define the binwidth

qplot(Statut_marital, data=df, binwidth=4) 
## Warning in geom_bar(binwidth = 4): Ignoring unknown parameters: `binwidth`

ggplot(df, aes(x=Hp1)) + geom_histogram()
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

ggplot(df, aes(x=Hp1)) + geom_histogram(binwidth=4)#define the binwidth

Créer un boxplot (diagramme à moustache)

Avec les fonction basiques de R:

Exemple:

boxplot(Hp2 ~ Statut_marital, data = df)

boxplot(Hp1 ~ Sexe, data = df)

Avec ggplot:

Exemple:

qplot(df$Statut_marital, df$Hp2, geom="boxplot")

qplot(Statut_marital, Hp2, data=df, geom="boxplot") #two vectors are already in the same data frame

ggplot(df, aes(x=Statut_marital, y=Hp2)) + geom_boxplot() #Idem

qplot(interaction(df$Statut_marital, df$Hp1), df$Hp2, geom="boxplot")

Tracer une courbe de fonction

Avec les fonction basiques de R:

curve(x^3 - 5*x, from=-4, to=4)#simple curve

myfun <- function(xvar) {# Plot a user-defined function
  1/(1 + exp(-xvar + 10))
}
curve(myfun(x), from=0, to=20)#Plot a curve
curve(1-myfun(x), add = TRUE, col = "red")# Add a line:

Avec ggplot:

ggplot(data.frame(x=c(0, 20)), aes(x=x)) + stat_function(fun=myfun, geom="line") #Idem

VISUALISATION DES DONNÉES AVEC GGPLOT2

ggplot2 est un package de visualisation de données pour le langage R, l’un des plus élégant et polyvalent. Il repose sur la Grammaire des graphiques (Grammar of Graphics), une approche systématique pour construire des graphiques complexes en combinant des couches. ggplot2 divise les graphiques en plusieurs composants (données, esthétique, géométrie, etc.), que l’utilisateur peut combiner pour créer des visualisations personnalisées.

Un graphique ggplot est construit en étapes ou couches avec cette syntaxe de base :

ggplot(data = data_frame, aes(x = x_variable, y = y_variable)) + geom_fonction() + options supplémentaires

Autrement:

ggplot(data = DATA) + GEOM_FUNCTION(mapping = aes(MAPPINGS), stat = STAT, position = POSITION) + COORDINATE_FUNCTION + FACET_FUNCTION

Le jeu de données (data), les esthétiques (aes) et la géométrie (geom) sont des paramètres obligatoires pour tracer un graphique avec ggplot2. Les autres paramètres sont facultatifs mais contribuent hautement à l’élégance du graphique.

Les types de géométries :

  • geom_point() : pour les graphiques de dispersion (scatter plots).
  • geom_line() : pour les graphiques en ligne.
  • geom_histogram et geom_bar() : pour les histogrammes ou les diagrammes en barres.
  • geom_boxplot() : pour les boxplots.
  • geom_density() : pour les courbes de densité.
  • etc.

Personnalisation :

ggplot2 permet de personnaliser quasiment tous les aspects des graphiques :

  • Couleurs, police, tailles, formes des points ou des lignes.
  • Thèmes de graphiques (avec theme() ou des thèmes préconstruits comme theme_minimal()).
  • Titres, légendes, annotations, etc.

Exemple de construction de graphiques avec gglot2

Dans les exemples qui vont suivre, nous allons soit utiliser la base des données importées ci-haut (et qui sera rendu disponible pour raisons d’exercice) “base_exercicesurR.xlsx” ou les bases des données intégrées aux packages R, ou des jeux de fausses données crées.

ggplot2 fait partie des packages de base de tidyverse. Si ce dernier est déjà installé, il suffira de le charger (activer) et les fonctions de ggplot2 seront utilisables. Cepdendant, ggplot2 peut être installé et chargé séparément en utilisant les commades:

install.packages("ggplot2")
library(ggplot2)

Dans cet exemple, nous souhaitons évaluer dans quelle mesure les résultats des deux tests, Hp1 et Hp2, sont corrélés pour détecter une infection. Cette corrélation peut être visualisée à l’aide d’un nuage de points. Les deux tests présentent une corrélation positive si les points tendent à se regrouper le long de la diagonale. Le nuage de points peut être représenté à l’aide de l’option geom_point du package ggplot2. Dans la commande, il est indispensable de spécifier le jeu de données (data) ainsi que le mapping des variables esthétiques (aes). Les autres paramètres seront automatiquement gérés par R en utilisant les options par défaut, à moins qu’ils ne soient explicitement définis dans la commande.

library(readxl) # package qui permet d'important une base des données Excel ou csv. Si le package n'est pas installé, l'installer.
setwd("/Volumes/MySD24933/Administration/UM") # spécifie le répertoire ou dossierde travail et oú se trouve la base des données. À spécifier en fonction de sa machine
getwd() # affiche le répertoire de travail
## [1] "/Volumes/MySD24933/Administration/UM"
df <- read_excel("base_exercicesurR.xlsx", sheet = "base_exercicesurR", na = "") # df est nom du jeu de données (data frame) ou base des données à être utilisé.
names(df) # affiche les noms de variables
## [1] "Hp1"            "Res1"           "Hp2"            "Res2"          
## [5] "Sexe"           "Age"            "Statut_marital" "disease"
str(df) # affiche le type de variables et quelques données pour chaque variable (structure des variables)
## tibble [425 × 8] (S3: tbl_df/tbl/data.frame)
##  $ Hp1           : num [1:425] 10.8 8.6 13.1 13.7 8.2 11.5 14.2 7 11.8 15.1 ...
##  $ Res1          : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
##  $ Hp2           : num [1:425] 10 10 10.1 10.2 10.2 10.3 10.4 10.5 10.6 10.7 ...
##  $ Res2          : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
##  $ Sexe          : chr [1:425] "Féminin" "Masculin" "Féminin" "Masculin" ...
##  $ Age           : num [1:425] 27 34 49 67 48 43 30 22 25 70 ...
##  $ Statut_marital: chr [1:425] "Marie" "Marie" "Marie" "Marie" ...
##  $ disease       : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) # Hp1 et Hp2 sont deux variables quantitatives qui représentent les résultats de deux tests de dosage.

On peut observer dans la figure ci-dessus que les points tendent à se regrouper autour de la diagonale, ce qui indique une certaine corrélation entre les tests Hp1 et Hp2.

Avec ggplot2, vous commencez un tracé avec la fonction ggplot(). ggplot() crée un système de coordonnées auquel vous pouvez ajouter des calques ou couches. Le premier argument de ggplot() est le jeu de données à utiliser dans le graphique. Ainsi, ggplot(data = df) crée un graphique vide, consititué uniquement du systéme de coordonées ou des axes. Vous complétez votre graphique en ajoutant un ou plusieurs calques/couches à ggplot(). La fonction geom_point() ajoute une couche de points à votre tracé, ce qui crée un nuage de points. ggplot2 est fourni avec de nombreuses fonctions geom qui ajoutent chacune un type de calque différent à un tracé, un peu comme nous l’avons mentionné ci-haut. Chaque fonction geom dans ggplot2 prend un argument mapping qui définit comment les variables du jeu de données sont mappées aux propriétés visuelles. L’argument mapping est toujours associé à aes(), et les arguments x et y de aes() spécifient les variables à mapper aux axes x et y. ggplot2 recherche la variable mappée dans l’argument de données, dans ce cas, df.

La syntaxe de base pour tracer un graphique avec ggplot2 es présente donc comme ceci:

ggplot(data = ) + (mapping = aes())

Décortiquons cette syntaxe en commençans avec le paramétre ou l’élément mapping.

Aesthetic Mappings

Le paramètre esthétique (aesthetic) fait référence à une propriété visuelle des éléments du graphique. Il englobe des aspects tels que la taille, la forme ou la couleur des points. Vous pouvez personnaliser l’apparence des points en modifiant les valeurs de ces propriétés esthétiques. Le terme « niveau » est utilisé pour désigner les variations de ces propriétés. Par exemple, les niveaux de taille, de forme et de couleur d’un point peuvent être ajustés pour qu’il devienne petit, triangulaire ou bleu, entre autres.

Vous pouvez transmettre des informations sur vos données en associant les propriétés esthétiques de votre tracé aux variables de votre jeu de données. Par exemple, il est possible de mapper la couleur des points à une variable telle que le sexe, afin de visualiser le genre de chaque participant pour lequel les résultats des tests sont présentés:

ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe))

Pour mapper une esthétique à une variable, associez le nom de l’esthétique (par exemple:x, y, color, shape, size, alpha, etc.) au nom de la variable à l’intérieur de aes(). ggplot2 attribuera automatiquement un niveau unique de l’esthétique (ici une couleur unique) à chaque valeur unique de la variable, un processus connu sous le nom de mise à l’échelle (scaling). ggplot2 ajoutera également une légende qui explique quels niveaux correspondent à quelles valeurs.

ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe, size = Age)) # l'esthétique size gère la taille d'affichage de la variable numérique à laquelle elle est mappée

ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe, alpha = Age)) 

# l'esthétique alpha gère la transparence d'affichage de la variable numérique à laquelle elle est mappée
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe, shape = Statut_marital)) 

# l'esthétique shape gère la fome d'affichage de la variable qualitative à laquelle elle est mappée
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2), color = "pink") # On peu ausi afficher tous les point en rose.

Remarquez la hiérarchie des parenthèses. En effet, dés lors que l’esthétique color ne se mappe avec aucune variable du jeu de données, elle doit être en dehors de aes(). Dans ce cas, la couleur ne se réfère pas à une variable en particulier mais correspond à l’apparence générale du graphique. C’est la même chose lorsqu’on veut donner aux points d’autres formes que les cerceles affichés par défaut; de même lorsqu’on veut personnaliser la taille des fromes.

ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe), shape=9, size = 8)

# Lorsque shape renvoie à l'allure générale du graphique, il doit être spécifié en termes de numéros variants de 0 à 24.
# Remarquez également la taille des formes ajustée à 8.

La fonction facet

La fonction supplémentaire et facultaive facet() permet de présenter un même graphique en fonction d’autre d’une variable qualitative. Nous pouvons tracer les nuages des points pour Hp1 et Hp2 par sexe et par statut marital par exemple:

ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_wrap(~ Sexe, nrow = 2) # nrow = 2 veut dire que le nombre de lignes est de 2, soit une figure au dessus et une autre en bas.

ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_wrap(~ Sexe, ncol = 2) # ncol = 2 veut dire que le nombre de colonnes est de 2, soit une figure à gauche et une autre à droite.

On peut aussi éclater un même type de figure en fonction de deux variables qualitatives. Par exemple nuage des points de Hp1 et Hp2 en fonction des variables Sexe et Statut_marital. Il faut alors utiliser la fonction facet_grid() et y ajouter les deux variables qualitatives sépérées par le ~.

ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_grid(Sexe ~ Statut_marital)

Remarquez ci-dessus les autres applications de fonction facet_grid() lorsque l’une des variables est remplacée par un “.”.

# Premier cas de figure:
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_grid(. ~ Statut_marital)

# Deuxiéme cas de figure:
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_grid(Statut_marital ~ .)

La fontion geom (ou l’objet géométrque)

Un geom est l’objet géométrique qu’un tracé utilise pour représenter des données. Les gens décrivent souvent les tracés par le type de geom qu’il utilise. Par exemple, les graphiques à barres utilisent des geoms à barres, les graphiques linéaires utilisent des geoms à lignes, les boxplots utilisent des geoms à boîtes, etc. Les nuages de points utilisent le geom de point. Différents geoms peuvent être utilisés pour tracer les mêmes données. Pour modifier le geom dans un tracé, modifiez la fonction geom que vous ajoutez à ggplot().

Dans les figures qui suivent, le premier tracé utilise le geom de point et le deuxième tracé utilise le geom lisse, une ligne lisse adaptée aux données, le troisième est une combinaison des deux et le quatrième une combinaison de deux premiers avec la ligne tracée en fonction du sexe

# Premier tracé
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2))

# Deuxième tracé
ggplot(data = df) +
geom_smooth(mapping = aes(x = Hp1, y = Hp2))
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'

# Combinaison de deux
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) + 
  geom_smooth(mapping = aes(x = Hp1, y = Hp2))
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'

# Combinaison de deux avec la ligne tracée en fonction du sexe
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) + 
  geom_smooth(mapping = aes(x = Hp1, y = Hp2, linetype = Sexe))
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'

Cependant, la combinaison de geoms comme dans les deux derniers tracés peut entraîner une certaine duplication dans le code. Par exemple, si l’on souhaite modifier l’axe des Y pour afficher Age au lieu de Hp2, il faudrait modifier la variable à deux endroits, ce qui augmente le risque d’oublier une mise à jour. Pour éviter ce type de répétition, il est possible de passer un ensemble de mappages directement à la fonction ggplot(). Ces mappages seront alors traités comme des mappages globaux, s’appliquant automatiquement à chaque geom du graphique.

Exemple:

ggplot(data = df, mapping = aes(x = Hp1, y = Hp2)) + geom_point() + geom_smooth()
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'

Autres exemples de codes (remarquez la différence entre les fonctions group et color):

# Exemple premier
ggplot(data = df) +
geom_smooth(mapping = aes(x = Hp1, y = Hp2, group = Sexe))
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'

# Exemple deuxiéme
ggplot(data = df) +
geom_smooth(
mapping = aes(x = Hp1, y = Hp2, color = Sexe),
show.legend = FALSE
)
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'

On peut aussi, en combinant plusieurs geoms, décider des données à afficher dans le tracé en utilisant par exemple la fonction filter.

# Exemple premier
ggplot(data = df, mapping = aes(x = Hp1, y = Hp2)) +
geom_point(mapping = aes(color = Sexe)) +
geom_smooth(
data = filter(df, disease == "1"),
se = FALSE
)
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'

# Exemple deuxième
ggplot(data = df, mapping = aes(x = Hp1, y = Hp2)) +
geom_point(mapping = aes(color = Sexe)) +
geom_smooth(
data = filter(df, disease == 0),
se = FALSE,
color="black",
linewidth=4
)
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'

Transformations statistiques

Le terme stat, abréviation de statistical transformation, désigne l’algorithme employé pour calculer de nouvelles valeurs destinées à un graphique. Chaque geom possède une transformation statistique par défaut (stat), et, inversement, chaque stat est associée à un geom par défaut. Ainsi, ces deux éléments peuvent généralement être utilisés de manière interchangeable, ce qui permet d’employer un geom sans nécessairement se préoccuper de la transformation statistique sous-jacente.

Prenons l’exemple de la fonction geom_bar(). La documentation associée (?geom_bar) révèle que la valeur par défaut de stat est count. En conséquence, l’utilisation de geom_bar() revient à recourir implicitement à stat_count(). Ainsi, les deux lignes de code suivantes produisent des résultats équivalents:

ggplot(data = df) + stat_count(mapping = aes(x = Statut_marital))

ggplot(data = df) + geom_bar(mapping = aes(x = Statut_marital))

Cependant, il existe trois situations où l’usage explicite d’une transformation statistique (stat) peut s’avérer nécessaire ou pertinent: * Modifier la statistique par défaut : Par exemple, dans le code suivant, la transformation statistique par défaut de geom_bar(), à savoir count, est remplacée par identity. Cette substitution permet de mapper la hauteur des barres à des valeurs brutes d’une variable y.

demo <- tribble(
~a,
~b,
"bar_1", 20,
"bar_2", 30,
"bar_3", 40
)

print(demo)
## # A tibble: 3 × 2
##   a         b
##   <chr> <dbl>
## 1 bar_1    20
## 2 bar_2    30
## 3 bar_3    40
ggplot(data = demo) +
geom_bar(
mapping = aes(x = a, y = b), stat = "identity"
)

  • Redéfinir le mappage des variables transformées : Il peut être souhaitable de remplacer le mappage par défaut pour obtenir une représentation différente des données. Par exemple, on peut vouloir visualiser un graphique à barres représentant des proportions plutôt que des effectifs bruts:
ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, y = after_stat(prop), group = 1) # "after_stat(prop)" remplace "..prop.." devenu obsolète.  
)

  • Mettre en évidence la transformation statistique dans le code : L’usage d’une fonction comme stat_summary(), qui synthétise les valeurs y pour chaque valeur unique de x, permet de souligner explicitement le résumé statistique effectué. Cela peut être utile pour attirer l’attention sur la logique ou les calculs sous-jacents.
ggplot(data = df) +
stat_summary(
mapping = aes(x = Statut_marital, y = Age),
fun.ymin = min,
fun.ymax = max,
fun.y = median
)
## Warning: The `fun.y` argument of `stat_summary()` is deprecated as of ggplot2 3.3.0.
## ℹ Please use the `fun` argument instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
## Warning: The `fun.ymin` argument of `stat_summary()` is deprecated as of ggplot2 3.3.0.
## ℹ Please use the `fun.min` argument instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
## Warning: The `fun.ymax` argument of `stat_summary()` is deprecated as of ggplot2 3.3.0.
## ℹ Please use the `fun.max` argument instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.

Autre exemple avec taille barres ajustée à y.

ggplot(data = df) +
geom_bar(mapping = aes(x = Statut_marital, y = after_stat(prop)))

ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, fill = Sexe, y = after_stat(prop))
)

Ajustement de la position

On peut colorer un graphique à barres en utilisant soit l’esthétique des couleurs, soit, plus utilement, la fonction fill (remplissage).

ggplot(data = df) +
geom_bar(mapping = aes(x = Sexe, color = Statut_marital))

ggplot(data = df) +
geom_bar(mapping = aes(x = Sexe, fill = Statut_marital)) 

# Notez que lorsque l'esthétique de remplissage "fill" est mappée à une autre variable, comme "Statut_marital", les barres sont automatiquement empilées (stacked bar chart).

L’empilement (stacking) des barres est réalisé automatiquement grâce à l’ajustement de position défini par l’argument position. Si on souhaite éviter l’affichage sous forme de barres empilées (stacked bars), il est possible de recourir à l’une des trois options suivantes pour l’argument position :identity, dodge ou fill. * position = “identity” : Cette option positionne chaque objet exactement à sa place dans le contexte du graphique, sans aucun ajustement supplémentaire. Cependant, pour les graphiques à barres, cette méthode entraîne souvent un chevauchement des barres, ce qui peut nuire à la lisibilité. Afin de mieux visualiser ce chevauchement, plusieurs solutions peuvent être envisagées: ** Rendre les barres partiellement transparentes : Cela peut être réalisé en attribuant une petite valeur à l’argument alpha. ** Rendre les barres entièrement transparentes : Cette approche consiste à définir fill = NA.

ggplot(
data = df,
mapping = aes(x = Statut_marital, fill = Sexe)
) +
geom_bar(alpha = 1/5, position = "identity")

ggplot(
data = df,
mapping = aes(x = Statut_marital, color = Sexe)
) +
geom_bar(fill = NA, position = "identity")

  • L’option position = “fill” fonctionne de manière similaire à l’empilement (stacking), mais avec une différence clé: elle ajuste la hauteur de chaque ensemble de barres empilées pour les rendre identiques. Cette normalisation facilite la comparaison des proportions entre les différents groupes.

En utilisant cette méthode, chaque segment d’une barre représente une proportion relative, permettant ainsi d’examiner des distributions comparatives tout en éliminant l’influence des variations absolues des effectifs entre les groupes.

ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, fill = Sexe),
position = "fill"
)

  • L’option position = “dodge” dispose les objets qui se chevauchent côte à côte, au lieu de les empiler. Cette disposition permet une comparaison plus aisée des valeurs individuelles, en rendant chaque segment distinct et facilement identifiable.

Cette méthode est particulièrement utile lorsqu’il s’agit de comparer directement des sous-groupes au sein de différentes catégories, tout en évitant l’encombrement visuel associé à l’empilement ou au chevauchement.

ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, fill = Sexe),
position = "dodge"
)

Systèmes de coordonnées

Les systèmes de coordonnées constituent probablement l’un des aspects les plus complexes de ggplot2. Par défaut, le package utilise le système de coordonnées cartésiennes, où les positions sur les axes x et y sont déterminées indépendamment afin de localiser chaque point sur le graphique. Cependant, ggplot2 propose plusieurs systèmes alternatifs qui peuvent s’avérer utiles dans des contextes spécifiques : * coord_flip() : Cette fonction permet d’inverser les axes x et y. Elle est particulièrement utile pour certaines visualisations, comme les boîtes à moustaches horizontales (horizontal boxplots). De plus, elle offre une solution élégante pour les graphiques comportant des étiquettes longues; en effet, ces dernières sont souvent difficiles à ajuster sans chevauchement sur l’axe des x.

ggplot(data = df, mapping = aes(x = Statut_marital, y = Age)) +
geom_boxplot()

ggplot(data = df, mapping = aes(x = Statut_marital, y = Age)) +
geom_boxplot() +
coord_flip()

  • coord_quickmap(): La fonction coord_quickmap() ajuste correctement le rapport hauteur/largeur d’un graphique, ce qui est particulièrement essentiel lors de la création de cartes ou de visualisations impliquant des données spatiales avec ggplot2. En maintenant des proportions fidèles, cette méthode garantit une représentation visuellement cohérente et réaliste des distances et des formes géographiques.
nz <- map_data("nz")

ggplot(nz, aes(long, lat, group = group)) +
geom_polygon(fill = "white", color = "black")

ggplot(nz, aes(long, lat, group = group)) +
geom_polygon(fill = "white", color = "black") +
coord_quickmap()

  • coord_polar(): cette fonction applique un système de coordonnées polaires, offrant une perspective unique et visuellement distinctive. Ce système révèle une connexion fascinante entre deux types de graphiques: le graphique à barres traditionnel et le graphique en éventail de type Coxcomb (également appelé graphique en rosace).

En transformant les barres rectangulaires en segments circulaires, les coordonnées polaires permettent de représenter les données d’une manière qui met en valeur des motifs ou des proportions d’une façon souvent plus intuitive ou esthétiquement frappante. Cette méthode est particulièrement utile pour les visualisations où les relations angulaires ou radiales entre les données sont importantes.

bar <- ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, fill = Sexe),
show.legend = FALSE,
width = 1
) +
theme(aspect.ratio = 1) +
labs(x = NULL, y = NULL)

bar + coord_flip()

bar + coord_polar()

Themes

Dans ggplot2, le paramètre theme() permet de modifier les éléments graphiques non liés aux données, comme : * Le fond du graphique, * Les grilles, * Les axes (titre, étiquettes, graduation), * La légende, * Le texte, la taille et les couleurs.

Syntaxe de base :

ggplot(data, aes(x, y)) + geom_point() + theme(…)

** Structure et Composants de theme()**

La fonction theme() contrôle chaque élément du graphique via des éléments thématiques appelés *element_**. Voici les principaux :

  • Fond du graphique ** panel.background : Fond du panneau où se trouve le tracé principal. ** plot.background : Fond global, y compris autour du panneau. ** panel.grid.major et panel.grid.minor : Grilles principales et secondaires.

Exemple:

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  theme(
    panel.background = element_rect(fill = "lightblue"),  # Fond du panneau
    plot.background = element_rect(fill = "gray90")      # Fond global
  )

  • Axes ** axis.title.x et axis.title.y : Titre des axes. ** axis.text.x et axis.text.y : Texte des étiquettes des axes. ** axis.ticks : Marques des graduations. ** axis.line : Lignes des axes.

Exemple :

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  theme(
    axis.title.x = element_text(color = "blue", size = 14, face = "bold"),  # Titre de l'axe X
    axis.text.y = element_text(color = "red", size = 12)                   # Étiquettes de l'axe Y
  )

  • Texte global ** text : Propriété générale pour tout le texte. ** plot.title : Titre du graphique. ** plot.subtitle : Sous-titre. ** plot.caption : Légende ou texte sous le graphique.

Exemple :

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  labs(title = "Correlation entre les deux tests", subtitle = "Résultats numériques du test Hp2 comparé au test Hp1") +
  theme(
    plot.title = element_text(size = 18, face = "bold", hjust = 0.5),  # Centrer et styliser le titre
    plot.subtitle = element_text(size = 14, face = "italic", hjust = 0.5) # Sous-titre en italique
  )

  • Légende ** legend.position : Position de la légende (“none”, “left”, “right”, “top”, “bottom” ou coordonnées c(x, y)). ** legend.background : Fond de la légende. ** legend.title et legend.text : Titre et texte de la légende.

Exemple :

ggplot(df, aes(Hp1, Hp2, color = Sexe)) +
  geom_point() +
  theme(
    legend.position = "bottom",                          # Légende en bas
    legend.background = element_rect(fill = "gray90"),  # Fond de la légende
    legend.title = element_text(face = "bold"),         # Titre en gras
    legend.text = element_text(size = 10)               # Texte plus petit
  )

  • Grilles ** panel.grid.major : Grilles principales. ** panel.grid.minor : Grilles secondaires.

Vous pouvez supprimer ou styliser les grilles :

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  theme(
    panel.grid.major = element_line(color = "gray", linetype = "dotted"),  # Grille principale
    panel.grid.minor = element_blank()                                    # Suppression des grilles secondaires
  )

Thèmes Prédéfinis

ggplot2 offre des thèmes prêts à l’emploi, qui modifient automatiquement l’apparence générale du graphique :

Principaux thèmes : * theme_gray() (par défaut) : Fond gris avec grilles blanches. * theme_bw() : Fond blanc avec des grilles noires. * theme_minimal() : Design épuré avec des grilles légères. * theme_classic() : Fond blanc avec des axes classiques. * theme_void() : Supprime tout sauf le tracé.

Exemple :

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  theme_minimal()  # Application du thème minimaliste

Combinaison plusieurs modifications

Vous pouvez combiner les ajustements dans une seule commande theme() pour un contrôle total :

Exemple

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  theme_minimal() +  # Base avec un thème minimaliste
  theme(
    plot.title = element_text(size = 16, face = "bold", hjust = 0.5),
    axis.text.x = element_text(color = "blue"),
    axis.ticks = element_line(color = "red"),
    panel.grid.major = element_line(color = "gray", linetype = "dotted")
  )

Pour voir la liste complète des options disponibles, utilisez : ?theme

Paramètres scale_x_* et scale_y_*

Dans ggplot2, les paramètres scale_x_ et scale_y_ permettent de contrôler l’échelle et l’apparence des axes X et Y. Ils jouent un rôle essentiel pour personnaliser :

  • Les limites des axes,
  • Les graduations et les étiquettes,
  • La transformation des données (logarithmique, racine carrée, etc.),
  • L’apparence esthétique des axes.

Les types de fonctions scale_x et scale_y

Ces fonctions permettent de gérer deux aspects principaux : * Limites et transformation des axes (par ex. scale_x_continuous pour les axes numériques). * Ajustement des données catégoriques ou discrètes (par ex. scale_x_discrete pour les axes avec des catégories(variable qualitative)).

Les variantes de scale_x et scale_y : * scale_x_continuous et scale_y_continuous : Pour des données numériques continues. * scale_x_discrete et scale_y_discrete : Pour des données qualitatives (facteurs). * scale_x_log10 et scale_y_log10 : Pour une échelle logarithmique. * scale_x_reverse et scale_y_reverse : Pour inverser l’axe. * scale_x_date et scale_y_date : Pour les axes temporels (dates). * scale_x_datetime et scale_y_datetime : Pour les données de type date-heure. * scale_x_sqrt et scale_y_sqrt : Pour une échelle basée sur la racine carrée.

** Paramètres des fonctions scale_x_* et scale_y_*

Voici les paramètres principaux disponibles pour personnaliser les axes :

  • Limites (limits) ** Définit les bornes des axes (min et max). ** Syntaxe :

scale_x_continuous(limits = c(min, max))

Exemple :

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  scale_x_continuous(limits = c(0, 600)) +  # Bornes de l'axe X entre 0 et 600
  scale_y_continuous(limits = c(0, 600)) # Bornes de l'axe Y entre 0 et 600

  • Graduation (breaks) ** Contrôle où se placent les graduations des axes. ** Syntaxe :

scale_x_continuous(breaks = c(1, 2, 3, 4, 5))

Exemple :

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  scale_x_continuous(breaks = seq(0, 500, by = 50))  # Graduation tous les 50 sur X

  • Étiquettes (labels) ** Permet de personnaliser les étiquettes affichées sur les axes. ** Syntaxe :

scale_x_continuous(labels = c(“petit”, “moyen”, “grand”))

Exemple :

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  scale_x_continuous(breaks = c(100, 200, 300), labels = c("Bas", "Moyen", "Elevé")) # Étiquettes personnalisées

  • Transformation (trans) ** Applique une transformation mathématique aux données (logarithmique, racine carrée, etc.). ** Transformations disponibles : “log10”, “sqrt”, “reverse”, etc.

Exemple :

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  scale_x_continuous(trans = "log10")  # Transformation logarithmique pour l'axe X

  • Autres options importantes ** expand : Ajoute un espace vide entre les données et les bords du graphique. ** name : Modifie le titre de l’axe. ** oob : Gère les points hors des bornes (out of bounds), par exemple avec scales::oob_squish.

Exemple avec expand et name :

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  scale_x_continuous(name = "Résultat du test de référence", expand = c(0, 0))+  # Titre personnalisé pour l'axe X
  scale_y_continuous(expand = c(0,0))

  • Fonctionnement avec des axes catégoriques (discrets)

Les fonctions scale_x_discrete et scale_y_discrete permettent de personnaliser les axes avec des catégories (facteurs ou chaînes de caractères).

Exemples : * Réorganiser les catégories :

ggplot(df, aes(Sexe, Age)) +
  geom_boxplot() +
  scale_x_discrete(limits = c("Masculin", "Féminin"))  # Ordre personnalisé, au lieu de l'ordre par défaur qui est alphabétique

  • Renommer les catégories :
ggplot(df, aes(Sexe, Age)) +
  geom_boxplot() +
  scale_x_discrete(limits = c("Masculin", "Féminin"),
                   labels = c("Messieurs", "Mesdames"))  # Étiquettes personnalisées

  • Exemples combinés avec scale_x et scale_y

Exemple 1 : Limites et graduations personnalisées

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  scale_x_continuous(limits = c(50, 300), breaks = seq(50, 300, by = 50)) +  # Limites et graduations X
  scale_y_continuous(limits = c(40, 240), breaks = seq(40, 240, by = 40)) # Limites et graduations Y
## Warning: Removed 340 rows containing missing values or values outside the scale range
## (`geom_point()`).

Exemple 2 : Transformation logarithmique

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  scale_x_log10() +  # Échelle logarithmique pour X
  scale_y_continuous(trans = "sqrt")  # Racine carrée pour Y

Exemple 3 : Axes inversés

ggplot(df, aes(Hp1, Hp2)) +
  geom_point() +
  scale_x_reverse() +  # Inverser l'axe X
  scale_y_reverse()    # Inverser l'axe Y

Pour plus d’information, taper: ?scale_x_continuous ou ?scale_x_discrete

Exercice d’application

Le graphique ci-dessous présente les variables Sexe, Hp1 et Statut matrimonial du jeu de données fourni “base_exercicesurR.xlsx”. Question: Générer le code R ayant permis de le tracer.